#!/usr/bin/env python
# coding=utf-8

if __name__ == '__main__':
    """ for file debug"""
    import sys,os
    sys.path.insert(0,os.path.join( os.getcwd(), '..' ))

__author__ = 'vavava'

import MySQLdb
from vavava.base import LogAdapter

class DBAccessor(object):

    def __init__(self,pool_min=1,pool_max=20,db_name="wr_trace",host="localhost",
             port=3306,user="root",passwd="root",db="wr_trace",charset='utf-8',use_unicode=False,log=None):
        self.db_name=db_name
        self.db_host=host
        self.db_port=port
        self.db_user=user
        self.db_passwd=passwd
        self.db=db
        self.is_active=False
        self.log=LogAdapter(log)
        self.conn = log

    def getConnection(self):
        return DBConnection( "localhost",self.db_port,self.db_user,self.db_passwd,self.db,self.log )


class DBConnection:
    """ general db interface
    """
    def __init__(self,host="localhost",port="3306",user="root",
                 passwd="root",db="wr_trace",log=None):
        self.log= LogAdapter(log=log,mod_name="[wr_db_conn]")
        self.host=host
        self.port=port
        self.user=user
        self.passwd=passwd
        self.db=db
        self.conn=None
        self._cursor=None
        try:
            self._conn = MySQLdb.Connect(host=self.host,port=self.port,
                user=self.user,passwd=self.passwd,db=self.db)
        except Exception as e:
            self.connected=False
            self.log.exception(e)
            raise
        self._cursor = self._conn.cursor()

    def execute(self,sql,param=None):
        return self.conn.execute(sql,param)

    def query(self,sql,param=None):
        self.cursor.execute(sql)
        return self._cursor.fetchall()

    def begin(self):
        """
        @summary: 开启事务
        """
        self._conn.autocommit(0)

    def end(self):
        """
        @summary: 结束事务
        """
        self._conn.commit()

    def rollback(self):
        self._conn.rollback()

    def getAll(self,sql,param=None):
        """
        @summary: 执行查询，并取出所有结果集
        @param sql:查询ＳＱＬ，如果有查询条件，请只指定条件列表，并将条件值使用参数[param]传递进来
        @param param: 可选参数，条件列表值（元组/列表）
        @return: result list/boolean 查询到的结果集
        """
        if param is None:
            count = self._cursor.execute(sql)
        else:
            count = self._cursor.execute(sql,param)
        if count>0:
            result = self._cursor.fetchall()
        else:
            result = False
        return result

    def getOne(self,sql,param=None):
        """
        @summary: 执行查询，并取出第一条
        @param sql:查询ＳＱＬ，如果有查询条件，请只指定条件列表，并将条件值使用参数[param]传递进来
        @param param: 可选参数，条件列表值（元组/列表）
        @return: result list/boolean 查询到的结果集
        """
        if param is None:
            count = self._cursor.execute(sql)
        else:
            count = self._cursor.execute(sql,param)
        if count>0:
            result = self._cursor.fetchone()
        else:
            result = False
        return result

    def getMany(self,sql,num,param=None):
        """
        @summary: 执行查询，并取出num条结果
        @param sql:查询ＳＱＬ，如果有查询条件，请只指定条件列表，并将条件值使用参数[param]传递进来
        @param num:取得的结果条数
        @param param: 可选参数，条件列表值（元组/列表）
        @return: result list/boolean 查询到的结果集
        """
        if param is None:
            count = self._cursor.execute(sql)
        else:
            count = self._cursor.execute(sql,param)
        if count>0:
            result = self._cursor.fetchmany(num)
        else:
            result = False
        return result

    def insertOne(self,sql,value):
        """
        @summary: 向数据表插入一条记录
        @param sql:要插入的ＳＱＬ格式
        @param value:要插入的记录数据tuple/list
        @return: insertId 受影响的行数
        """
        self._cursor.execute(sql,value)
        return self.__getInsertId()

    def insertMany(self,sql,values):
        """
        @summary: 向数据表插入多条记录
        @param sql:要插入的ＳＱＬ格式
        @param values:要插入的记录数据tuple(tuple)/list[list]
        @return: count 受影响的行数
        """
        count = self._cursor.executemany(sql,values)
        return count

    def __getInsertId(self):
        """
        获取当前连接最后一次插入操作生成的id,如果没有则为０
        """
        self._cursor.execute("SELECT @@IDENTITY AS id")
        result = self._cursor.fetchall()
        return result[0]['id']

    def __query(self,sql,param=None):
        if param is None:
            count = self._cursor.execute(sql)
        else:
            count = self._cursor.execute(sql,param)
        return count

    def update(self,sql,param=None):
        """
        @summary: 更新数据表记录
        @param sql: ＳＱＬ格式及条件，使用(%s,%s)
        @param param: 要更新的  值 tuple/list
        @return: count 受影响的行数
        """
        return self.__query(sql,param)

    def delete(self,sql,param=None):
        """
        @summary: 删除数据表记录
        @param sql: ＳＱＬ格式及条件，使用(%s,%s)
        @param param: 要删除的条件 值 tuple/list
        @return: count 受影响的行数
        """
        return self.__query(sql,param)

    def dispose(self,isEnd=1):
        """
        @summary: 释放连接池资源
        """
        if isEnd==1:
            self.end('commit')
        else:
            self.end('rollback');
        self._cursor.close()
        self._conn.close()

    def __del__(self):
        if self._cursor:
            self._cursor.close()
            self._conn.close()

if __name__ == '__main__':
    pass

